import { defineEventHandler, getRouterParam, readBody, setResponseHeaders } from "h3";
import { getCurrentUser, getConfigUser, getConfigGlobal } from "#server/utils/context";
import { resolveAgentIdentity } from "#server/service/agent/identity";
import { getSessionByIdAndUser } from "#server/service/agent/session";
import { getAgentBySlug } from "#server/service/agent/agent";
import { executeChat } from "#server/service/agent/chat-engine";
import { registerAbortController, unregisterAbortController } from "#server/service/agent/abort-manager";
import type { ContentPart } from "#server/service/agent/types";

export default defineEventHandler(async (event) => {
  const agentSlug = getRouterParam(event, "agentSlug");
  if (!agentSlug) {
    throw createError({ statusCode: 400, statusMessage: "参数无效" });
  }

  const agent = await getAgentBySlug(agentSlug);
  if (!agent) {
    throw createError({ statusCode: 404, statusMessage: "agent 不存在" });
  }

  const identity = await resolveAgentIdentity(event);
  if (!identity.userId && !identity.tempToken) {
    throw createError({ statusCode: 401, statusMessage: "请先登录或创建临时会话" });
  }

  const body = await readBody(event);
  const { sessionId, parts, content, editMessageId, regenerate, continueAfterApproval, approvalToolCallId, approved, approvalReason, enableThinking, enableTools } = body as {
    sessionId: string;
    parts?: ContentPart[];
    content?: string;
    editMessageId?: string;
    regenerate?: boolean;
    continueAfterApproval?: boolean;
    approvalToolCallId?: string;
    approved?: boolean;
    approvalReason?: string;
    enableThinking?: boolean;
    enableTools?: boolean;
  };

  if (!sessionId) {
    throw createError({ statusCode: 400, statusMessage: "参数无效" });
  }

  const isApprovalContinue = continueAfterApproval === true && approvalToolCallId;
  if (!isApprovalContinue) {
    const hasParts = Array.isArray(parts) && parts.length > 0;
    const hasContent = typeof content === "string" && content.trim().length > 0;
    if (!hasParts && !hasContent) {
      throw createError({ statusCode: 400, statusMessage: "参数无效" });
    }
  }

  const session = await getSessionByIdAndUser(sessionId, identity.userId, identity.tempToken);
  if (!session) {
    throw createError({ statusCode: 404, statusMessage: "会话不存在" });
  }

  if (session.agentId !== agent.id) {
    throw createError({ statusCode: 400, statusMessage: "会话不属于该 agent" });
  }

  const ip = getRequestIP(event, { xForwardedFor: true }) || "unknown";

  let preferredModelId: number | null = null;
  let reviewApprovalMode: string = "manual";
  if (identity.userId) {
    preferredModelId = (await getConfigUser(event, "preferredLlmModelId")) ?? null;
    reviewApprovalMode = (await getConfigUser(event, "reviewApprovalMode")) ?? "manual";
  }

  const globalDefaultModelId = (await getConfigGlobal("agentDefaultModelId")) ?? null;

  const user = identity.userId ? await getCurrentUser(event) : null;

  const { response } = await executeChat({
    agent,
    session,
    user: user ? { id: user.id, role: user.role } : null,
    tempToken: identity.tempToken,
    body: {
      parts,
      content,
      editMessageId,
      regenerate,
      continueAfterApproval,
      approvalToolCallId,
      approved,
      approvalReason,
      enableThinking,
      enableTools,
    },
    ip,
    preferredModelId,
    globalDefaultModelId,
    reviewApprovalMode,
    requestId: event.context.requestId,
    registerAbort: registerAbortController,
    unregisterAbort: unregisterAbortController,
    setRateLimitHeaders: (headers) => {
      setResponseHeaders(event, headers);
    },
    onClientClose: (cb) => {
      event.node.req.on("close", cb);
    },
  });

  return response;
});